Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@packages/ballerina-extension/src/features/ai/agent/prompts.ts`:
- Around line 179-199: The system/user prompt mismatch: getSystemPrompt() states
the agent will receive either a "Codebase High Level Overview" or full source in
<codebase_structure>, but getUserPrompt() injects a "<Codebase High Level
Summary>" (codeMapMarkdown) and omits <codebase_structure>, which can make the
agent assume full source is present. Update the prompt construction so they are
consistent: modify getSystemPrompt() and/or getUserPrompt() to use the same
terminology and explicit contract (either always provide <codebase_structure>
when mentioning full source or change getSystemPrompt() to reference "<Codebase
High Level Summary>"/codeMapMarkdown), and ensure any logic that sets
codeMapMarkdown vs. codebase_structure toggles the corresponding text blocks;
search for and update the prompt assembly functions getSystemPrompt and
getUserPrompt (and related template builders) to keep wording and conditional
injection aligned.

In `@packages/ballerina-extension/src/features/ai/agent/tools/glob.ts`:
- Around line 95-102: The ripgrep subprocess result (proc from spawnSync in
glob.ts) must be checked for proc.error before treating null/empty stdout as "No
matches"; add a guard in the function that calls spawnSync/getRgExecutable to
detect proc.error (including buffer-limit or spawn failures) and return
fail(...) with the proc.error message/details instead of falling through to the
RgExitCode.NoMatches branch; apply the same proc.error check to the analogous
grep tool implementation so real tool failures aren't masked as "no files
found".

In `@packages/ballerina-extension/src/features/ai/agent/tools/grep.ts`:
- Around line 148-157: The current matchCount overcounts because matchLines uses
/^\d+[:\-]/ which treats context lines prefixed with "-" as matches; update the
logic that builds matchLines (used when constructing the GrepResult object in
this block) to only count true match lines by matching line numbers followed by
':' (e.g. /^\d+:/) so matchCount reflects actual matches; keep the
displayed/truncation behavior unchanged and ensure the GrepResult.matchCount
uses the new filtered array length.

In `@packages/ballerina-extension/src/features/ai/agent/tools/text-editor.ts`:
- Line 927: Fix the typos in the tool's user-facing description string in
packages/ballerina-extension/src/features/ai/agent/tools/text-editor.ts: change
"insted" to "instead" and "that components" to "those components". Locate the
description used when registering or defining the tool (search for the sentence
fragment "From the Codebase High Level Summary, If you know the line range of
components to read," or the function/constant that registers the tool, e.g., the
tool's description parameter) and update the string accordingly.

In `@packages/ballerina-extension/src/features/ai/agent/tools/utils/rg-utils.ts`:
- Around line 27-30: The current logic returns the full stdout from
spawnSync(whichCmd, ["rg"], ...) which on Windows ("where") can contain multiple
paths; change the return to parse result.stdout, split by newlines, trim each
line and return only the first non-empty path (use the existing whichCmd/result
variables and the same spawnSync call), so subsequent spawnSync invocations use
a single valid executable path (apply this normalization for both win32 and
non-win32 cases).

In `@packages/ballerina-extension/test/ai/evals/code/utils/evaluator-utils.ts`:
- Line 310: The code unsafely casts toolCall.input to
ContextRetrievalEvaluationResult; add a runtime validation step (e.g., use the
existing Zod schema or a custom type guard) to verify shape before casting: call
schema.safeParse(toolCall.input) (or run the guard) and handle the failure path
(log/throw) if validation fails, otherwise assign evaluationResult =
parsed.data; update any references to evaluationResult to rely on the validated
value (symbols: toolCall.input, ContextRetrievalEvaluationResult,
evaluationResult).

In `@packages/ballerina-extension/test/data/healthcare_sample/mapping.bal`:
- Line 45: The mapping uses direct first-element access on patient.name[0].given
in mapGivenToName which will panic if name or given arrays are empty; update the
mapping to guard before dereferencing by checking patient.name is not empty and
patient.name[0].given is not empty (or use safe navigation/optional access) and
only call mapGivenToName when those checks pass; apply the same pattern for the
other occurrences referenced around lines 53-56 (e.g., any uses of
patient.name[0] or patient.name[0].given).
- Line 34: The fallback literal for patient gender is misspelled and can break
the enum cast in the expression using <uscore311:USCorePatientProfileGender> and
patient?.gender; change the fallback from "unkown" to the correct "unknown" (or
to the exact enum member name expected by
<uscore311:USCorePatientProfileGender>) so the cast succeeds when patient.gender
is absent.
- Around line 27-32: The mapping currently generates id and identifier[0].value
independently (using patient?.id ?: uuid:createType1AsString() and patient?.id
?: generatePatientId()), causing mismatches when source id is absent; fix by
computing a single local variable (e.g., generatedId) once using the fallback
logic (patient?.id ?: ...) and use that variable for both the id field and
identifier[0].value so both values are consistent in one mapping pass.

In `@packages/ballerina-extension/test/data/healthcare_sample/service.bal`:
- Around line 131-133: The Location header currently builds
`${SERVER_BASE_URL}/Patient/${dbResponse[0]}` which is incorrect for this
service; update the response.addHeader call to return the full exposed resource
path by including the service prefix (e.g. use
`${SERVER_BASE_URL}/fhir/r4/Patient/${dbResponse[0]}`) so that callers are
directed to the actual route; modify the response.addHeader(http:LOCATION, ...)
invocation (and keep response.statusCode = http:STATUS_CREATED) to use the
corrected path.

In `@packages/ballerina-extension/test/data/hotel_reservation/utils.bal`:
- Around line 48-57: The overlap predicate in getAllocatedRooms is too
restrictive and misses partial overlaps; replace the where clause that uses
"userCheckinUTC <= rCheckin && userCheckoutUTC >= rCheckout" with the standard
interval-overlap check using the variables userCheckinUTC, userCheckoutUTC,
rCheckin and rCheckout (i.e., ensure the condition enforces userCheckinUTC <
rCheckout && userCheckoutUTC > rCheckin) so roomReservations that partially
overlap the requested window are also returned.

In
`@packages/ballerina-extension/test/data/order_management_system/order_service/Ballerina.toml`:
- Around line 7-10: Update the dependency org for the order_utils entry in the
order_service Ballerina.toml so it matches the workspace package and imports:
change the [[dependency]] block that currently has org = "yasithrashan" name =
"order_utils" to use org = "wso2" (or remove the dependency so the local
workspace package is used), ensuring it aligns with order_utils/Ballerina.toml
and the import statement in order_service/functions.bal (import
wso2/order_utils;).

In
`@packages/ballerina-extension/test/data/order_management_system/order_service/modules/db/db_operations.bal`:
- Around line 12-20: The call to resultStream.next() can early-return on error
and skip resultStream.close(), leaking the stream; update the code around the
dbClient->query(...) resultStream so you call resultStream.close() in all paths
(both success and error) — e.g. capture the result of resultStream.next() into a
var, check whether it returned an error and if so call resultStream.close()
before propagating the error, or use a try/finally-style pattern to ensure
resultStream.close() is always executed after using resultStream (referencing
resultStream.next() and resultStream.close()).

In
`@packages/ballerina-extension/test/data/order_management_system/order_utils/utils.bal`:
- Around line 23-24: The function calculateLineTotal currently allows negative
quantities; add a guard at the start of calculateLineTotal to validate that
quantity is >= 0 and fail fast if not (e.g., panic or abort with a clear message
that includes the invalid quantity), then proceed to compute and return
unitPrice * <decimal>quantity; reference the calculateLineTotal function and the
parameters unitPrice and quantity when applying this check.

In
`@packages/ballerina-extension/test/data/salesforce_slack_integration_errors/functions.bal`:
- Line 190: The call that builds the Slack lookup URL concatenates email
directly into slackHttpClient->get("/api/users.lookupByEmail?email=" + email) so
reserved characters may break the request; import the URL module (import
ballerina/url as url), call url:encode(email) and use check to capture errors
(e.g., string encodedEmail = check url:encode(email)), then pass the
encodedEmail into slackHttpClient->get instead of the raw email to ensure a
correct, encoded query string.

In
`@packages/ballerina-extension/test/data/salesforce_slack_integration_errors/main.bal`:
- Around line 67-74: The current onUpdate flow marks processedLeadIds[leadId] =
true inside the initial lock before downstream work, which causes failed
processing to be permanently skipped; change the logic so the lock only reserves
the lead (e.g., insert an "in-flight" marker or a temporary placeholder) to
prevent concurrent processing, release the lock, run the downstream queries and
Slack notification, and only upon successful completion set
processedLeadIds[leadId] = true (or replace the in-flight marker with the final
marker) inside another short lock; ensure that on any error you remove the
in-flight reservation (or do not commit the final mark) so retries can
succeed—refer to processedLeadIds, the lock block, and onUpdate to locate where
to implement this change.

In
`@packages/ballerina-extension/test/data/salesforce_slack_integration/functions.bal`:
- Around line 184-194: The Slack lookup URL concatenates the raw email in
getSlackUserIdFromEmail which can break if the email contains reserved
characters; before calling
slackHttpClient->get("/api/users.lookupByEmail?email=" + email) encode the email
using ballerina/url:encode (or the equivalent URL-encoding helper) and use the
encoded value in the query string so the request is safe for all valid email
characters.

In
`@packages/ballerina-extension/test/data/salesforce_slack_integration/main.bal`:
- Around line 67-74: The code records processedLeadIds[leadId] inside the lock
before downstream work succeeds (in the lock block that checks
processedLeadIds.hasKey), which causes permanent skips on transient failures and
unbounded growth; change the logic in onUpdate so you only mark
processedLeadIds[leadId] = true after all downstream actions (Salesforce
queries/Slack send) complete successfully (still using the lock to guard the
check-and-set), and if you must set it earlier ensure you remove the entry on
any failure inside the same lock; additionally implement a bounded eviction/TTL
mechanism for processedLeadIds (e.g., time-based expiry or size cap with
LRU/queue) to prevent unbounded memory growth.

---

Nitpick comments:
In
`@packages/ballerina-extension/test/ai/evals/code/result-management/report-generator.ts`:
- Around line 192-195: The console.log in report-generator.ts is printing both
an emoji and the boolean for context relevance (using ctx.is_relevant) which is
redundant; update the logging inside the block that checks
result.contextRetrievalEvaluation so it only prints the emoji/state (e.g., keep
`Context Retrieval: ${ctx.is_relevant ? '✅' : '❌'}`) and remove the trailing
"Relevant: ${ctx.is_relevant}" portion, modifying the statement that references
ctx and ctx.is_relevant accordingly.
- Around line 166-169: The console.log in the result handling for
result.contextRetrievalEvaluation prints both an emoji and the boolean value
(using ctx.is_relevant); remove the redundant boolean display by changing the
log to only show the emoji (or emoji plus descriptive label) — locate the block
where result.contextRetrievalEvaluation is assigned to ctx and update the
console.log that currently reads `Context Retrieval: ${ctx.is_relevant ? '✅' :
'❌'} Relevant: ${ctx.is_relevant}` to a single concise output such as `Context
Retrieval: ${ctx.is_relevant ? '✅' : '❌'}`.